use anyhow::{anyhow, Result};
use calamine::{open_workbook, DataType, Reader, Xlsx};
use chrono::{Datelike, NaiveDate, NaiveDateTime};
use clap::Parser;
use log::{error, info};
use regex::Regex;
use rust_xlsxwriter::{Color, Format, Workbook, Worksheet};
use serde::{Deserialize, Serialize};
use serde_json::Value;
use simple_logger::SimpleLogger;
use std::collections::{HashMap, HashSet};
use std::fs::File;
use std::io::{self, BufRead, BufReader};
use std::iter;
use std::path::Path;

/// Excel数据处理工具，用于合并和处理Excel和CSV文件中的订单数据
#[derive(Parser, Debug)]
#[command(author, version, about, long_about = None)]
struct Args {
    /// Excel文件路径，可以指定多个文件
    #[arg(long, value_name = "FILE")]
    excel: Option<Vec<String>>,

    /// PayPal CSV文件路径，可以指定多个文件
    #[arg(long, value_name = "FILE")]
    paypal: Option<Vec<String>>,

    /// 云汇 CSV文件路径，可以指定多个文件
    #[arg(long, value_name = "FILE")]
    air: Option<Vec<String>>,

    /// 输出Excel文件名
    #[arg(long, value_name = "FILE")]
    output: Option<String>,

    /// 交互模式
    #[arg(long)]
    interactive: bool,
}

/// 配置文件结构
#[derive(Debug, Serialize, Deserialize)]
struct Config {
    file_paths: FilePaths,
    output: OutputConfig,
    keywords: Vec<String>,
    known_channels: Vec<String>,
    main_data: MainData,
}

#[derive(Debug, Serialize, Deserialize)]
struct FilePaths {
    excel_files: Vec<String>,
    paypal_csv_files: Vec<String>,
    air_csv_files: Vec<String>,
}

#[derive(Debug, Serialize, Deserialize)]
struct OutputConfig {
    export_file_name: String,
    auto_name: bool,
}

#[derive(Debug, Serialize, Deserialize)]
struct MainData {
    header: Vec<String>,
    numeric_fields: Vec<String>,
    payment_status_filter: Vec<String>,
    paypal_header: Vec<String>,
    paypal_checkout_types: Vec<String>,
    air_header: Vec<String>,
    air_checkout_types: Vec<String>,
}

/// 默认配置
fn default_config() -> Config {
    Config {
        file_paths: FilePaths {
            excel_files: Vec::new(),
            paypal_csv_files: Vec::new(),
            air_csv_files: Vec::new(),
        },
        output: OutputConfig {
            export_file_name: String::new(),
            auto_name: true,
        },
        keywords: vec![
            "订单编号".to_string(),
            "支付订单号".to_string(),
            "交易号".to_string(),
            "交易编号".to_string(),
            "货币单位".to_string(),
            "订单总价".to_string(),
        ],
        known_channels: vec!["长沙".to_string(), "华宁".to_string(), "尼彩".to_string()],
        main_data: MainData {
            header: vec![
                "支付订单号".to_string(),
                "货币单位".to_string(),
                "订单总价".to_string(),
                "商品总价".to_string(),
                "优惠金额".to_string(),
                "物流费用".to_string(),
                "支付状态".to_string(),
                "支付方式1".to_string(),
                "支付渠道1".to_string(),
                "支付金额1".to_string(),
                "最后一次互动来源".to_string(),
                "订单确认时间".to_string(),
            ],
            numeric_fields: vec![
                "订单总价".to_string(),
                "商品总价".to_string(),
                "优惠金额".to_string(),
                "物流费用".to_string(),
            ],
            payment_status_filter: vec!["部分退款".to_string(), "已支付".to_string()],
            paypal_header: vec![
                "交易号".to_string(),
                "币种".to_string(),
                "总额".to_string(),
                "费用".to_string(),
                "净额".to_string(),
                "类型".to_string(),
                "状态".to_string(),
                "来源".to_string(),
            ],
            paypal_checkout_types: vec![
                "快速结账付款".to_string(),
                "直接信用卡付款".to_string(),
                "预先批准付款账单用户付款".to_string(),
            ],
            air_header: vec![
                "交易编号".to_string(),
                "交易币种".to_string(),
                "交易金额".to_string(),
                "授权状态返回描述".to_string(),
                "交易状态".to_string(),
                "来源".to_string(),
            ],
            air_checkout_types: vec![
                "FULLY REFUNDED".to_string(),
                "PARTIALLY REFUNDED".to_string(),
                "SUCCEEDED".to_string(),
                "DISPUTED".to_string(),
            ],
        },
    }
}

/// 加载配置文件
fn load_config(config_path: &str) -> Result<Config> {
    if Path::new(config_path).exists() {
        let file = File::open(config_path)?;
        let config: Config = serde_json::from_reader(file)?;
        info!("已加载配置文件: {}", config_path);
        Ok(config)
    } else {
        // 创建默认配置文件
        let config = default_config();
        let file = File::create(config_path)?;
        serde_json::to_writer_pretty(file, &config)?;
        info!("已创建默认配置文件: {}", config_path);
        Ok(config)
    }
}

/// 创建唯一的文件名，如果文件已存在则添加序号
fn create_filename(filename: &str) -> String {
    let name = filename.to_string();
    let path = Path::new(&name);
    let base_name = path.file_stem().unwrap().to_str().unwrap();
    let extension = path.extension().unwrap_or_default().to_str().unwrap();

    let mut count = 1;
    let mut result = name.clone();

    while Path::new(&result).exists() {
        result = format!("{base_name}({count}).{extension}");
        count += 1;
    }
    result
}

/// 根据文件名确定渠道
fn determine_channel(file_path: &str, known_channels: &[String]) -> String {
    let file_name = Path::new(file_path).file_name().unwrap().to_str().unwrap();

    for channel in known_channels {
        if file_name.contains(channel) {
            return channel.clone();
        }
    }

    // 如果没有匹配的已知渠道，返回文件名的前两个字符
    if file_name.chars().count() > 2 {
        return file_name.chars().take(2).collect();
    }

    String::new()
}

/// 计算月份的最后一天
fn last_day_of_month(year: i32, month: u32) -> u32 {
    // 如果是12月，则下个月是下一年的1月
    let (next_year, next_month) = if month == 12 {
        (year + 1, 1)
    } else {
        (year, month + 1)
    };

    // 下个月的第一天减去一天就是当前月的最后一天
    NaiveDate::from_ymd_opt(next_year, next_month, 1)
        .unwrap()
        .pred_opt()
        .unwrap()
        .day()
}

/// 判断日期是否为月末最后一天
fn is_last_day_of_month(date_str: &str) -> bool {
    if date_str.is_empty() {
        return false;
    }

    // 尝试解析标准格式日期字符串
    if let Ok(date) = NaiveDateTime::parse_from_str(date_str, "%Y-%m-%d %H:%M:%S") {
        let day = date.day();
        let last_day = last_day_of_month(date.year(), date.month());
        return day == last_day;
    }

    // 尝试解析其他常见格式
    let patterns = [
        Regex::new(r"^(\d{4})[-./年](\d{1,2})[-./月](\d{1,2})").unwrap(),
        Regex::new(r"^(\d{1,2})[-./月](\d{1,2})[-./日],(\d{4})").unwrap(),
    ];

    for pattern in &patterns {
        if let Some(caps) = pattern.captures(date_str) {
            let year: i32 = caps[1].parse().unwrap_or(2000);
            let month: u32 = caps[2].parse().unwrap_or(1);
            let day: u32 = caps[3].parse().unwrap_or(1);

            let last_day = last_day_of_month(year, month);
            return day == last_day;
        }
    }

    false
}

/// 读取Excel文件并转换为JSON对象数组
fn get_xlsx_data(
    file_path: &str,
    header_row: Option<usize>,
    config: &Config,
) -> Result<Vec<HashMap<String, Value>>> {
    info!("读取文件: {}", file_path);

    let mut workbook: Xlsx<_> = open_workbook(file_path)?;
    let sheet_name = workbook
        .sheet_names()
        .get(0)
        .ok_or_else(|| anyhow!("没有找到工作表"))?
        .clone();
    let sheet = workbook.worksheet_range(&sheet_name)?;

    // 自动检测表头行
    let header_row = if let Some(row) = header_row {
        row
    } else {
        let mut detected_row = 0;
        for i in 0..std::cmp::min(9, sheet.height()) {
            let row = sheet.rows().nth(i).unwrap();
            if row.iter().any(|cell| {
                if let DataType::String(s) = cell {
                    config.keywords.contains(&s)
                } else {
                    false
                }
            }) {
                detected_row = i;
                break;
            }
        }
        detected_row
    };
    // 获取表头
    let header_row_data = sheet
        .rows()
        .nth(header_row)
        .ok_or_else(|| anyhow!("无法获取表头行"))?;
    let headers: Vec<String> = header_row_data
        .iter()
        .map(|cell| match cell {
            DataType::String(s) => s.clone(),
            _ => cell.to_string(), // 保持原始表示
        })
        .collect();

    // 转换数据
    let mut result = Vec::new();
    for row_idx in (header_row + 1)..sheet.height() {
        let row = sheet.rows().nth(row_idx).unwrap();
        let mut item = HashMap::new();
        // 添加来源字段
        item.insert(
            "来源".to_string(),
            Value::String(determine_channel(file_path, &config.known_channels)),
        );
        // 1. 优先处理支付订单号字段 - 直接使用原始字符串表示
        for (col_idx, header) in headers.iter().enumerate() {
            if header.contains("支付订单号") && col_idx < row.len() {
                // 直接获取单元格的原始字符串表示
                let raw_value = row[col_idx].to_string();
                item.insert("支付订单号".to_string(), Value::String(raw_value));
                break;
            }
        }
        // 2. 添加其他字段 - 保持原始表示
        for (col_idx, header) in headers.iter().enumerate() {
            // 跳过支付订单号字段
            if header.contains("支付订单号") {
                continue;
            }
            if col_idx < row.len() {
                // 直接使用原始字符串表示
                let raw_value = row[col_idx].to_string();
                item.insert(header.clone(), Value::String(raw_value));
            }
        }
        result.push(item);
    }
    
    info!("{}行", result.len());
    Ok(result)
}
/// 读取CSV文件数据
fn get_csv_data(file_path: &str, config: &Config) -> Result<Vec<HashMap<String, Value>>> {
    let mut results = Vec::new();
    let file = File::open(file_path)?;
    let reader = BufReader::new(file);
    let lines: Vec<String> = reader.lines().filter_map(Result::ok).collect();

    // 查找真正的CSV头部行
    let mut header_row = 0;
    for (i, line) in lines.iter().take(9).enumerate() {
        if config.keywords.iter().any(|keyword| line.contains(keyword))
        {
            header_row = i;
            break;
        }
    }

    // 解析CSV
    if header_row < lines.len() {
        let headers: Vec<String> = lines[header_row]
            .split(',')
            .map(|s| s.trim().trim_matches('"').to_string())
            .collect();

        for line in lines.iter().skip(header_row + 1) {
            let values: Vec<&str> = line.split(',').collect();
            if values.len() >= headers.len() {
                let mut row = HashMap::new();
                for (i, header) in headers.iter().enumerate() {
                    if i < values.len() {
                        let value = values[i].trim().trim_matches('"');
                        row.insert(header.clone(), Value::String(value.to_string()));
                    }
                }

                // 添加来源字段
                row.insert(
                    "来源".to_string(),
                    Value::String(determine_channel(file_path, &config.known_channels)),
                );
                results.push(row);
            }
        }
    }

    info!("CSV 读取完成，结果：{} 行", results.len());
    Ok(results)
}

/// 处理数据的通用函数
fn process_data<F>(
    data: &[HashMap<String, Value>],
    header: &[String],
    need_num: &[String],
    condition: F,
) -> Vec<HashMap<String, Value>>
where
    F: Fn(&HashMap<String, Value>) -> bool,
{
    let mut result = Vec::new();

    for item in data {
        // 检查支付状态是否符合条件
        if let Some(Value::String(status)) = item.get("支付状态") {
            if status == "部分退款" || status == "已支付" {
                if condition(item) {
                    let mut obj = HashMap::new();
                    for key in header {
                        let value = item.get(key).cloned().unwrap_or_else(|| Value::String(String::new()));
                        let processed_value = if need_num.contains(key) {
                            match value {
                                Value::String(s) => {
                                    // 使用更健壮的数字解析（处理千分位分隔符等）
                                    let cleaned = s.replace(",", "");
                                    cleaned.parse::<f64>()
                                        .ok()
                                        .and_then(|num| serde_json::Number::from_f64(num))
                                        .map(Value::Number)
                                        .unwrap_or_else(|| Value::Number(serde_json::Number::from(0)))
                                }
                                Value::Number(n) => Value::Number(n),
                                _ => Value::Number(serde_json::Number::from(0)),
                            }
                        } else {
                            value
                        };
                        obj.insert(key.clone(), processed_value);
                    }
                    result.push(obj);
                }
            }
        }
    }

    result
}

/// 根据输入文件名生成导出文件名
fn get_export_filename(files: &[String], name: Option<String>) -> String {
    if let Some(name) = name {
        return name;
    }

    if files.is_empty() {
        return "数据汇总.xlsx".to_string();
    }

    // 从第一个文件名提取前缀和日期范围
    let file_name = Path::new(&files[0]).file_name().unwrap().to_str().unwrap();
    let re = Regex::new(r"^([A-Za-z]{2,}).*?(\d+\.\d+-\d+\.\d+)").unwrap();

    if let Some(caps) = re.captures(file_name) {
        let prefix = &caps[1];
        let date_range = &caps[2];
        format!("{}{}{}", prefix, date_range, "汇总.xlsx")
    } else {
        "数据汇总.xlsx".to_string()
    }
}

/// 计算不同货币的总和
fn currency_sum(
    data: &[HashMap<String, Value>],
    cur_field: &str,
    sum_field: &str,
) -> HashMap<String, f64> {
    let mut currency_obj = HashMap::new();

    for item in data {
        // 跳过计数不为1的项
        if let Some(Value::Number(count)) = item.get("计数") {
            if let Some(count) = count.as_i64() {
                if count != 1 {
                    continue;
                }
            }
            // } else if let Some(Value::String(count_str)) = item.get("计数") {
            //     if count_str != "1" && !count_str.is_empty() {
            //         continue;
            //     }
        }

        if let Some(Value::String(currency)) = item.get(cur_field) {
            if !currency.is_empty() {
                // 安全地解析数值，无论它是字符串还是数字
                let amount = match item.get(sum_field) {
                    Some(Value::Number(n)) => n.as_f64().unwrap_or(0.0),
                    Some(Value::String(s)) => {
                        // 尝试解析字符串为数字，如果失败则返回0.0
                        let s = s.trim().replace(",", ""); // 移除可能的千位分隔符
                        s.parse::<f64>().unwrap_or(0.0)
                    }
                    _ => 0.0,
                };

                *currency_obj.entry(currency.clone()).or_insert(0.0) += amount;
            }
        }
    }

    currency_obj
}

/// 同时兼容两种格式读取
fn get_data(file_path: &str, config: &Config) -> Result<Vec<HashMap<String, Value>>> {
    let extension = Path::new(file_path)
        .extension()
        .and_then(|ext| ext.to_str())
        .unwrap_or("")
        .to_lowercase();

    match extension.as_str() {
        "csv" => get_csv_data(file_path, config),
        "xlsx" | "xls" => get_xlsx_data(file_path, None, config),
        _ => Err(anyhow!("不支持的文件格式: {}", extension)),
    }
}

/// 主函数，处理Excel和CSV数据并导出结果
fn process_files(
    excel_files: &[String],
    pay_csv_arr_file: &[String],
    air_csv_arr_file: &[String],
    export_file_name: Option<String>,
    config: &Config,
) -> Result<String> {
    // 读取Excel文件
    let mut new_data = Vec::new();
    for file_path in excel_files {
        let data = get_data(file_path, config)?;
        new_data.extend(data);
    }

    // 定义表头和数字字段
    let header = &config.main_data.header;
    let need_num = &config.main_data.numeric_fields;

    // 筛选条件1：部分退款或已支付，且支付渠道不是空中云汇
    let pay_data = process_data(&new_data, header, need_num, |item| {
        if let Some(Value::String(channel)) = item.get("支付渠道1") {
            channel != "空中云汇"
        } else {
            false
        }
    });

    // 筛选条件2：对应云汇
    let air_data = process_data(&new_data, header, need_num, |item| {
        if let Some(Value::String(channel)) = item.get("支付渠道1") {
            channel == "空中云汇"
        } else {
            false
        }
    });

    // 定义CSV数据的表头
    let header1 = &config.main_data.paypal_header;
    let checkout_types = &config.main_data.paypal_checkout_types;

    let header2 = &config.main_data.air_header;
    let checkout_types2 = &config.main_data.air_checkout_types;

    // 读取CSV数据
    let mut csv_data = Vec::new();
    for csv_file in pay_csv_arr_file {
        let data = get_data(csv_file, config)?;
        csv_data.extend(data);
    }

    let mut csv_data2 = Vec::new();
    for csv_file in air_csv_arr_file {
        let data = get_data(csv_file, config)?;
        csv_data2.extend(data);
    }

    // 处理PayPal数据
    let mut pay_data2 = Vec::new();
    for item in &pay_data {
        let mut is_repeat = false;

        for csv_item in &csv_data {
            let is_same = match (csv_item.get("交易号"), item.get("支付订单号")) {
                (Some(Value::String(csv_id)), Some(Value::String(item_id))) => csv_id == item_id,
                _ => false,
            };

            if is_same {
                let status_match = match csv_item.get("状态") {
                    Some(Value::String(status)) => status == "已完成",
                    _ => false,
                };

                let type_match = match csv_item.get("类型") {
                    Some(Value::String(type_val)) => checkout_types.contains(type_val),
                    _ => false,
                };

                if status_match && type_match {
                    // 检查订单确认时间是否为月末
                    let is_month_end = match item.get("订单确认时间") {
                        Some(Value::String(date)) => is_last_day_of_month(date),
                        _ => false,
                    };

                    let mut new_obj = HashMap::new();
                    for key in header1 {
                        let value = csv_item.get(key).cloned().unwrap_or_else(|| Value::String(String::new()));
                        let processed_value = if ["总额", "费用", "净额"].contains(&key.as_str()) {
                            match value {
                                Value::String(s) => {
                                    // 使用更健壮的数字解析（处理千分位分隔符等）
                                    // let cleaned = s.replace(|c: char| !c.is_ascii_digit() && c != '.' && c != '-', "");
                                    let cleaned = s.replace(",", "");
                                    cleaned.parse::<f64>()
                                        .ok()
                                        .and_then(|num| serde_json::Number::from_f64(num))
                                        .map(Value::Number)
                                        .unwrap_or_else(|| Value::Number(serde_json::Number::from(0)))
                                }
                                Value::Number(n) => Value::Number(n),
                                _ => Value::Number(serde_json::Number::from(0)),
                            }
                        } else {
                            value
                        };
                        new_obj.insert(key.clone(), processed_value);

                    }

                    new_obj.insert(
                        "计数".to_string(),
                        Value::Number(serde_json::Number::from(1)),
                    );
                    if is_repeat {
                        let val = new_obj
                            .get("计数")
                            .and_then(|v| v.as_u64()) // 尝试解析为无符号整数
                            .unwrap_or(0);
                        new_obj.insert(
                            "计数".to_string(),
                            Value::Number(serde_json::Number::from(val + 1)),
                        );
                    }

                    // 如果是月末，添加标记
                    if is_month_end {
                        new_obj.insert("_isMonthEnd".to_string(), Value::Bool(true));
                    }

                    is_repeat = true;
                    pay_data2.push(new_obj);
                }
            }
        }
    }

    // 处理云汇数据
    let mut air_data2 = Vec::new();
    for item in &air_data {
        let mut is_repeat = false;

        for csv_item in &csv_data2 {
            let is_same = match (csv_item.get("交易编号"), item.get("支付订单号")) {
                (Some(Value::String(csv_id)), Some(Value::String(item_id))) => csv_id == item_id,
                _ => false,
            };

            if is_same {
                let status_match = match csv_item.get("交易状态") {
                    Some(Value::String(status)) => checkout_types2.contains(status),
                    _ => false,
                };

                if status_match {
                    // 检查订单确认时间是否为月末
                    let is_month_end = match item.get("订单确认时间") {
                        Some(Value::String(date)) => is_last_day_of_month(date),
                        _ => false,
                    };

                    let mut new_obj = HashMap::new();
                    for key in header2 {
                        let value = csv_item.get(key).cloned().unwrap_or_else(|| Value::String(String::new()));
                        let processed_value = if ["交易金额"].contains(&key.as_str()) {
                            match value {
                                Value::String(s) => {
                                    // 使用更健壮的数字解析（处理千分位分隔符等）
                                    let cleaned = s.replace(",", "");
                                    cleaned.parse::<f64>()
                                        .ok()
                                        .and_then(|num| serde_json::Number::from_f64(num))
                                        .map(Value::Number)
                                        .unwrap_or_else(|| Value::Number(serde_json::Number::from(0)))
                                }
                                Value::Number(n) => Value::Number(n),
                                _ => Value::Number(serde_json::Number::from(0)),
                            }
                        } else {
                            value
                        };
                        new_obj.insert(key.clone(), processed_value);
                        
                    }

                    new_obj.insert(
                        "计数".to_string(),
                        Value::Number(serde_json::Number::from(1)),
                    );
                    if is_repeat {
                        let val = new_obj
                            .get("计数")
                            .and_then(|v| v.as_u64()) // 尝试解析为无符号整数
                            .unwrap_or(0);
                        new_obj.insert(
                            "计数".to_string(),
                            Value::Number(serde_json::Number::from(val + 1)),
                        );
                    }

                    // 如果是月末，添加标记
                    if is_month_end {
                        new_obj.insert("_isMonthEnd".to_string(), Value::Bool(true));
                    }

                    is_repeat = true;
                    air_data2.push(new_obj);
                }
            }
        }
    }

    // 计算货币汇总
    let pay_sum = currency_sum(&pay_data, "货币单位", "订单总价");
    let air_sum = currency_sum(&air_data, "货币单位", "订单总价");
    let pay_sum2 = currency_sum(&pay_data2, "币种", "总额");
    let air_sum2 = currency_sum(&air_data2, "交易币种", "交易金额");

    // 合并所有货币类型
    let mut currency_set = HashSet::new();
    for currency in pay_sum.keys() {
        currency_set.insert(currency.clone());
    }
    for currency in air_sum.keys() {
        currency_set.insert(currency.clone());
    }
    for currency in pay_sum2.keys() {
        currency_set.insert(currency.clone());
    }
    for currency in air_sum2.keys() {
        currency_set.insert(currency.clone());
    }

    // 创建汇总数据
    let mut total_data = Vec::new();
    for currency in currency_set {
        let mut obj = HashMap::new();
        obj.insert("币种".to_string(), Value::String(currency.clone()));
        obj.insert(
            "店铺筛paypal".to_string(),
            Value::Number(
                serde_json::Number::from_f64(*pay_sum.get(&currency).unwrap_or(&0.0)).unwrap(),
            ),
        );
        obj.insert(
            "paypal".to_string(),
            Value::Number(
                serde_json::Number::from_f64(*pay_sum2.get(&currency).unwrap_or(&0.0)).unwrap(),
            ),
        );
        obj.insert(
            "店铺筛云汇".to_string(),
            Value::Number(
                serde_json::Number::from_f64(*air_sum.get(&currency).unwrap_or(&0.0)).unwrap(),
            ),
        );
        obj.insert(
            "云汇".to_string(),
            Value::Number(
                serde_json::Number::from_f64(*air_sum2.get(&currency).unwrap_or(&0.0)).unwrap(),
            ),
        );
        total_data.push(obj);
    }

    // 按币种排序
    total_data.sort_by(|a, b| {
        let a_currency = match a.get("币种") {
            Some(Value::String(s)) => s,
            _ => "",
        };
        let b_currency = match b.get("币种") {
            Some(Value::String(s)) => s,
            _ => "",
        };
        a_currency.cmp(b_currency)
    });

    // 创建Excel工作簿
    let mut workbook = Workbook::new();

    // 导出数据到各个工作表
    let mut sheet1 = workbook.add_worksheet().set_name("原始数据")?;
    export_sheet_data(&mut sheet1, &new_data, true)?;
    let mut sheet2 = workbook.add_worksheet().set_name("店铺筛Paypal")?;
    export_sheet_data(&mut sheet2, &pay_data, true)?;
    let mut sheet3 = workbook.add_worksheet().set_name("csv-PayPal")?;
    export_sheet_data(&mut sheet3, &pay_data2, true)?;
    let mut sheet4 = workbook.add_worksheet().set_name("店铺筛云汇")?;
    export_sheet_data(&mut sheet4, &air_data, true)?;
    let mut sheet5 = workbook.add_worksheet().set_name("csv-云汇订单")?;
    export_sheet_data(&mut sheet5, &air_data2, true)?;
    let mut sheet6 = workbook.add_worksheet().set_name("汇总")?;

    // 为汇总表指定列顺序
    let summary_columns = vec![
        "币种".to_string(),
        "店铺筛paypal".to_string(),
        "paypal".to_string(),
        "店铺筛云汇".to_string(),
        "云汇".to_string(),
    ];
    export_sheet_data_with_columns(&mut sheet6, &total_data, &summary_columns, false)?;

    // 获取导出文件名
    let e_file_name = get_export_filename(excel_files, export_file_name);
    let output_file = create_filename(&e_file_name);

    // 保存工作簿
    workbook.save(&output_file)?;
    info!("Excel 文件导出成功！{}", output_file);

    Ok(output_file)
}

/// 导出数据到Excel工作表，指定列顺序
fn export_sheet_data_with_columns(
    worksheet: &mut Worksheet,
    data: &[HashMap<String, Value>],
    columns: &[String],
    auto_filter: bool,
) -> Result<()> {
    if data.is_empty() {
        return Ok(());
    }

    // 创建黄色背景格式
    let yellow_format = Format::new().set_background_color(Color::RGB(0xFFFF00));

    // 写入表头
    for (col_idx, column) in columns.iter().enumerate() {
        worksheet.write_string(0, col_idx as u16, column)?;
    }

    // 写入数据
    for (row_idx, item) in data.iter().enumerate() {
        let is_month_end = item
            .get("_isMonthEnd")
            .and_then(|v| v.as_bool())
            .unwrap_or(false);

        for (col_idx, column) in columns.iter().enumerate() {
            if let Some(value) = item.get(column) {
                let row = (row_idx + 1) as u32;
                let col = col_idx as u16;

                match value {
                    Value::String(s) => {
                        if is_month_end {
                            worksheet.write_string_with_format(row, col, s, &yellow_format)?;
                        } else {
                            worksheet.write_string(row, col, s)?;
                        }
                    }
                    Value::Number(n) => {
                        if let Some(f) = n.as_f64() {
                            if is_month_end {
                                worksheet.write_number_with_format(row, col, f, &yellow_format)?;
                            } else {
                                worksheet.write_number(row, col, f)?;
                            }
                        } else if let Some(i) = n.as_i64() {
                            if is_month_end {
                                worksheet.write_number_with_format(
                                    row,
                                    col,
                                    i as f64,
                                    &yellow_format,
                                )?;
                            } else {
                                worksheet.write_number(row, col, i as f64)?;
                            }
                        }
                    }
                    Value::Bool(b) => {
                        if is_month_end {
                            worksheet.write_boolean_with_format(row, col, *b, &yellow_format)?;
                        } else {
                            worksheet.write_boolean(row, col, *b)?;
                        }
                    }
                    _ => {}
                }
            }
        }
    }

    // 设置自动筛选
    if auto_filter && !data.is_empty() {
        worksheet.autofilter(0, 0, data.len() as u32, columns.len() as u16 - 1)?;
    }

    Ok(())
}

/// 导出数据到Excel工作表
fn export_sheet_data(
    worksheet: &mut Worksheet,
    data: &[HashMap<String, Value>],
    auto_filter: bool,
) -> Result<()> {
    if data.is_empty() {
        return Ok(());
    }

    // 收集所有可能的列名
    let mut all_columns = HashSet::new();
    for item in data {
        for key in item.keys() {
            if key != "_isMonthEnd" {
                // 排除内部标记字段
                all_columns.insert(key.clone());
            }
        }
    }

    // 转换为有序列表
    let mut columns: Vec<String> = all_columns.into_iter().collect();
    columns.sort(); // 按字母顺序排序列名

    // 优先处理特定列
    let priority_columns = vec![
        "支付订单号",
        "交易号",
        "交易编号",
        "币种",
        "交易币种",
        "货币单位",
        "订单总价",
        "总额",
        "交易金额",
    ];
    for &col in priority_columns.iter().rev() {
        if let Some(pos) = columns.iter().position(|x| x == col) {
            columns.remove(pos);
            columns.insert(0, col.to_string());
        }
    }

    // 创建黄色背景格式
    let yellow_format = Format::new().set_background_color(Color::RGB(0xFFFF00));

    // 写入表头
    for (col_idx, column) in columns.iter().enumerate() {
        worksheet.write_string(0, col_idx as u16, column)?;
    }

    // 写入数据
    for (row_idx, item) in data.iter().enumerate() {
        let is_month_end = item
            .get("_isMonthEnd")
            .and_then(|v| v.as_bool())
            .unwrap_or(false);

        for (col_idx, column) in columns.iter().enumerate() {
            if let Some(value) = item.get(column) {
                let row = (row_idx + 1) as u32;
                let col = col_idx as u16;

                match value {
                    Value::String(s) => {
                        if is_month_end {
                            worksheet.write_string_with_format(row, col, s, &yellow_format)?;
                        } else {
                            worksheet.write_string(row, col, s)?;
                        }
                    }
                    Value::Number(n) => {
                        if let Some(f) = n.as_f64() {
                            if is_month_end {
                                worksheet.write_number_with_format(row, col, f, &yellow_format)?;
                            } else {
                                worksheet.write_number(row, col, f)?;
                            }
                        } else if let Some(i) = n.as_i64() {
                            if is_month_end {
                                worksheet.write_number_with_format(
                                    row,
                                    col,
                                    i as f64,
                                    &yellow_format,
                                )?;
                            } else {
                                worksheet.write_number(row, col, i as f64)?;
                            }
                        }
                    }
                    Value::Bool(b) => {
                        if is_month_end {
                            worksheet.write_boolean_with_format(row, col, *b, &yellow_format)?;
                        } else {
                            worksheet.write_boolean(row, col, *b)?;
                        }
                    }
                    _ => {}
                }
            }
        }
    }

    // 设置自动筛选
    if auto_filter && !data.is_empty() {
        let last_col = columns.len() as u16 - 1;
        let last_row = data.len() as u32;
        worksheet.autofilter(0, 0, last_row, last_col)?;
    }

    // 设置列宽
    for (col_idx, _) in columns.iter().enumerate() {
        worksheet.set_column_width(col_idx as u16, 15.0)?; // 默认列宽
    }

    // 特定列的宽度调整
    if let Some(pos) = columns
        .iter()
        .position(|x| x == "支付订单号" || x == "交易号" || x == "交易编号")
    {
        worksheet.set_column_width(pos as u16, 20.0)?;
    }

    Ok(())
}

/// 交互式命令行界面
fn interactive_mode() -> Result<()> {
    SimpleLogger::new()
        .with_level(log::LevelFilter::Info)
        .init()
        .unwrap_or(());

    let config = load_config("config.json")?;

    loop {
        println!("小娇娇Excel数据处理工具 (Rust版)");
        println!(
            "{}",
            [
                iter::repeat("*").take(30).collect::<String>(),
                "注意事项".to_string(),
                iter::repeat("*").take(30).collect::<String>()
            ]
            .join("")
        );
        println!("1.文件命名最好要规范");
        println!("2.csv文件需要把头部无关信息删除");
        println!("3.csv文件支持转成xlsx文件读取");
        println!("4.文件夹路径 在文件管理最上方输入框获取");
        println!("5.命令行中 ↑ ↓ 箭头切换粘贴信息,鼠标右键直接粘贴选项");
        println!("6.直接按 Enter 键结束");
        println!("7.可以修改config.json配置文件自定义参数");
        println!("{}", iter::repeat("*").take(70).collect::<String>());

        // 检查配置文件中是否有预设的文件路径
        let mut excel_files = config.file_paths.excel_files.clone();
        let mut pay_csv_files = config.file_paths.paypal_csv_files.clone();
        let mut air_csv_files = config.file_paths.air_csv_files.clone();
        let mut export_file_name = config.output.export_file_name.clone();

        let mut use_config = false;

        // 检查配置文件中是否有预设的文件路径
        if !excel_files.is_empty() && (!pay_csv_files.is_empty() || !air_csv_files.is_empty()) {
            println!("\n检测到配置文件中有预设的文件路径:");
            println!("Excel文件: {}", excel_files.join(", "));
            println!("PayPal CSV文件: {}", pay_csv_files.join(", "));
            println!("云汇 CSV文件: {}", air_csv_files.join(", "));

            println!("是否使用配置文件中的设置？(Y/N): ");
            let mut input = String::new();
            io::stdin().read_line(&mut input)?;
            if input.trim().to_lowercase() == "y" {
                use_config = true;
            }
        }

        if !use_config {
            println!("\n请输入以下信息：");

            // 获取Excel文件路径
            excel_files.clear();
            loop {
                println!("Excel店铺文件路径 (输入空行结束): ");
                let mut input = String::new();
                io::stdin().read_line(&mut input)?;
                let input = input.trim();

                if input.is_empty() {
                    break;
                }

                if Path::new(input).exists() {
                    excel_files.push(input.to_string());
                } else {
                    println!("文件不存在: {}", input);
                }
            }

            if excel_files.is_empty() {
                println!("错误：至少需要一个Excel文件");
                continue;
            }

            // 获取PayPal CSV文件路径
            pay_csv_files.clear();
            loop {
                println!("PayPal CSV文件路径(输入空行结束): ");
                let mut input = String::new();
                io::stdin().read_line(&mut input)?;
                let input = input.trim();

                if input.is_empty() {
                    break;
                }

                if Path::new(input).exists() {
                    pay_csv_files.push(input.to_string());
                } else {
                    println!("文件不存在: {}", input);
                }
            }

            // 获取云汇CSV文件路径
            air_csv_files.clear();
            loop {
                println!("云汇 CSV文件路径(输入空行结束): ");
                let mut input = String::new();
                io::stdin().read_line(&mut input)?;
                let input = input.trim();

                if input.is_empty() {
                    break;
                }

                if Path::new(input).exists() {
                    air_csv_files.push(input.to_string());
                } else {
                    println!("文件不存在: {}", input);
                }
            }

            // 获取输出文件名
            if !config.output.auto_name {
                println!("输出Excel文件名,需要后缀.xlsx (选填): ");
                let mut input = String::new();
                io::stdin().read_line(&mut input)?;
                export_file_name = input.trim().to_string();
            }
        }

        // 执行主函数
        match process_files(
            &excel_files,
            &pay_csv_files,
            &air_csv_files,
            if export_file_name.is_empty() {
                None
            } else {
                Some(export_file_name.clone())
            },
            &config,
        ) {
            Ok(output_file) => {
                println!("处理完成，输出文件: {}", output_file);
            }
            Err(e) => {
                error!("处理失败: {}", e);
                println!("处理失败: {}", e);
            }
        }

        // 询问是否继续处理下一批文件
        println!("\n是否继续处理下一批文件？(Y/N): ");
        let mut input = String::new();
        io::stdin().read_line(&mut input)?;
        if input.trim().to_lowercase() != "y" {
            println!("程序退出，感谢使用！");
            break;
        }
    }

    Ok(())
}

fn main() -> Result<()> {
    // 初始化日志
    SimpleLogger::new()
        .with_level(log::LevelFilter::Info)
        .init()
        .unwrap_or(());

    // 解析命令行参数
    let args = Args::parse();

    if args.interactive || (args.excel.is_none() && args.paypal.is_none() && args.air.is_none()) {
        // 交互模式
        interactive_mode()
    } else {
        // 加载配置文件
        let config = load_config("config.json")?;
        // 命令行模式
        let excel_files = args.excel.unwrap_or_default();
        let paypal_files = args.paypal.unwrap_or_default();
        let air_files = args.air.unwrap_or_default();

        if excel_files.is_empty() {
            return Err(anyhow!("错误：至少需要一个Excel文件"));
        }

        process_files(
            &excel_files,
            &paypal_files,
            &air_files,
            args.output,
            &config,
        )?;
        Ok(())
    }
}
